package com.lib.util;

import android.content.Context;
import android.os.Environment;
import android.text.TextUtils;
import android.webkit.MimeTypeMap;

import com.qbw.log.XLog;

import java.io.File;
import java.util.UUID;

/**
 * @author qbw
 * @createtime 2016/05/25 15:03
 */


public class FileUtil {

    /**
     * @param context
     * @param uniqueName
     * @return '缓存路径' + '/' + uniqueName
     */
    public static File getDiskCacheDir(Context context, String uniqueName) {
        // Check if media is mounted or storage is built-in, if so, try and use external cache dir
        // otherwise use internal cache dir
        return new File(isExternalStorageExist() ? context.getExternalCacheDir().getPath() : context
                .getCacheDir()
                .getPath() + File.separator + uniqueName);
    }

    /**
     * @param context
     * @return 缓存路径
     */
    public static File getDiskCacheDir(Context context) {
        return isExternalStorageExist() ? context.getExternalCacheDir() : context.getCacheDir();
    }

    /**
     * @param context
     * @return 保存文件的路径
     */
    public static File getFileDir(Context context) {
        return isExternalStorageExist() ? context.getExternalFilesDir(null) : context.getFilesDir();
    }

    /**
     * @param context
     * @return 如果存在sd卡则返回sd卡根目录, 否则返回内置'fileDir'
     */
    public static File getExternalStorageDir(Context context) {
        return isExternalStorageExist() ? Environment.getExternalStorageDirectory() : context.getFilesDir();
    }

    /**
     * @return 保存相机图片的路径
     */
    public static File getGalleryDir() {
        return isExternalStorageExist() ? new File(Environment.getExternalStorageDirectory(),
                                                   Environment.DIRECTORY_DCIM) : new File("");
    }

    /**
     * @return 是否存在外置sd卡
     */
    public static boolean isExternalStorageExist() {
        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) || !Environment
                .isExternalStorageRemovable();
    }

    /**
     * @param url
     * @return 文件后缀
     */
    public static String getFileExtensionFromUrl(String url) {
        return MimeTypeMap.getFileExtensionFromUrl(url);
    }

    /**
     * @param path
     * @return 文件后缀
     */
    public static String getFileExtensionFromPath(String path) {
        return path.substring(path.lastIndexOf(".") + 1);
    }

    public static String getFileNameFromPath(String path) {
        return path.substring(path.lastIndexOf("/") + 1);
    }

    /**
     * @param extension 文件后缀(文件格式)
     * @return 文件格式对应的Mime类型(比如'jpg'->'image/*')
     */
    public static String getMimeTypeFromExtension(String extension) {
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }

    public static void deleteFile(File file) {
        if (file == null) {
            if (XLog.isEnabled()) XLog.e("file is null");
            return;
        }
        if (file.exists()) {
            if (file.isFile()) {
                if (!file.delete()) {
                    if (XLog.isEnabled()) XLog.e("delete file %s failed", file.getAbsolutePath());
                }
            } else {
                File[] files = file.listFiles();
                int len = files == null ? 0 : files.length;
                for (int i = 0; i < len; i++) {
                    deleteFile(files[i]);
                }
            }
        } else {
            if (XLog.isEnabled()) XLog.w("file %s not exist", file.getAbsolutePath());
        }
    }

    /**
     * 删除文件
     *
     * @param filePath
     * @return
     */
    public static boolean deleteFile(String filePath) {
        File file = new File(filePath);
        if (file.exists()) {
            file.delete();
            return true;
        }
        return false;
    }

    /**
     * 删除目录下的文件
     *
     * @param filePath
     * @param delDir   是否删除目录
     * @return
     */
    public static boolean deleteDirectory(String filePath, boolean delDir) {
        return deleteDirectory(filePath, delDir, false);
    }

    public static boolean deleteDirectory(String filePath, boolean delDir, boolean onlyFile) {
        if (filePath == null) {
            return false;
        }
        // 如果sPath不以文件分隔符结尾，自动添加文件分隔符

        if (!filePath.endsWith(File.separator)) {
            filePath = filePath + File.separator;
        }
        File dirFile = new File(filePath);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        // 删除文件夹下的所有文件(包括子目录)
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            // 删除子文件
            if (files[i].isFile()) {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag) {
                    break;
                }
            } // 删除子目录
            else {
                if (!onlyFile) {
                    flag = deleteDirectory(files[i].getAbsolutePath());
                    if (!flag) {
                        break;
                    }
                }
            }
        }
        if (!flag) {
            return false;
        }

        if (delDir) {
            // 删除当前目录
            if (dirFile.delete()) {
                return true;
            } else {
                return false;
            }
        }
        return true;

    }

    /**
     * 删除目录（文件夹）以及目录下的文件
     *
     * @param filePath 被删除目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(String filePath) {
        return deleteDirectory(filePath, true);
    }

    /**
     * 根据URL获取文件名
     *
     * @param url
     * @param suffix
     * @return
     */
    public static String getFileNameFromUrl(String url, String suffix) {
        // 通过 ‘？’ 和 ‘/’ 判断文件名
        if (TextUtils.isEmpty(url)) {
            return "";
        }
        int index = url.lastIndexOf('?');
        String filename = null;
        try {
            int startLastxg = url.lastIndexOf('/') + 1;
            if (index > 1) {
                if (index < startLastxg) {
                    return getFileNameFromUrl(url.substring(0, index), suffix);
                }
                filename = url.substring(startLastxg, index);
            } else {
                filename = url.substring(startLastxg);
            }
        } catch (Exception e) {
        }
        if (filename == null || "".equals(filename.trim())) {// 如果获取不到文件名称
            filename = UUID.randomUUID() + suffix;// 默认取一个文件名
        }
        if (filename.indexOf(".") == -1) {
            filename = filename + suffix;
        }
        return filename;
    }

    /**
     * 判断是否是图片文件
     *
     * @param name
     * @return
     */
    public static boolean isImage(String name) {
        boolean flag = false;
        try {
            name = name.toLowerCase();
            if (name.endsWith(".jpg") || name.endsWith(".png") || name.endsWith(".jpeg") || name.endsWith(
                    ".bmp") || name.endsWith(".gif")) {
                flag = true;
            }
        } catch (Exception e) {
        }
        return flag;
    }

    /**
     * 通过文件后缀判断是不是gif
     *
     * @param url
     * @return
     */
    public static boolean isGif(String url) {
        if (TextUtils.isEmpty(url)) {
            return false;
        }
        String fileName = MimeTypeMap.getFileExtensionFromUrl(url);
        return "gif".equals(fileName);
    }

    public static boolean isPng(String path) {
        return getFileExtensionFromPath(path).equalsIgnoreCase("png");
    }

    public static boolean isJpg(String path) {
        String ext = getFileExtensionFromPath(path);
        return ext.equalsIgnoreCase("jpg") || ext.equalsIgnoreCase("jpeg");
    }

    public static boolean isUrl(String path) {
        if (TextUtils.isEmpty(path)) {
            return false;
        }
        return path.startsWith("http://") || path.startsWith("https://");
    }
}
